export class CommonUtils {

    static getDataType(o:any) {
        const s = Object.prototype.toString.call(o);
        const dataType = s.match(/\[object (.*?)\]/)[1];
        if(dataType){
            return dataType.toLowerCase();
        }else{
            return null;
        }
    }

    static isNull(o:any) {
        return this.getDataType(o) === 'null';
    }

    static isUndefined(o:any) {
        return this.getDataType(o) === 'undefined';
    }

    static isObject(o:any) {
        return this.getDataType(o) === 'object';
    }

    static isArray(o:any) {
        // return this.getDataType(o) === 'array';
        return Array.isArray(o);
    }

    static isString(o:any) {
        return this.getDataType(o) === 'string';
    }

    static isNumber(o:any) {
        return this.getDataType(o) === 'number';
    }

    static isBoolean(o:any) {
        return this.getDataType(o) === 'boolean';
    }

    static isDate(o:any) {
        return o instanceof Date;
    }

    /**
     * 深拷贝
     * @param target:目标
     * @param origin：源
     */
    static clone(target: any, origin:any) {
        const toStr = Object.prototype.toString;
        for (const prop in origin) {
            if (origin.hasOwnProperty(prop)) { // 排除原型链上的值
                if (this.isObject(origin[prop])) {
                    target[prop] = this.isArray(origin[prop]) ? [] : {};
                    this.clone(target[prop], origin[prop]);
                } else {
                    target[prop] = origin[prop];
                }
            }
        }
        return target;
    }

    /**
     * 空值过滤掉
     * @param obj：去除值为null、undefined、空字符串的字段
     * @param trim：如果是字符串，是否去除空格后再验证
     */
    static removeNullKey(obj: any, trim=false) {
        if (this.isObject(obj)) {
            Object.keys(obj).forEach(key => {
                if (this.isNullValue(obj[key], trim)) {
                    delete obj[key];
                }
            });
        }
        return obj;
    }

    /**
     * 是否为空值：符合空值的条件（空字符串、null、undefined、数组长度为0、对象中没有key）
     * @param v：被验证的值
     * @param trim：如果是字符串，是否去除空格后再验证
     */
    static isNullValue(v:any, trim=false) {
        if(this.isString(v) && trim){
            return !!v.replace(/\s+/g, '');
        }
        if(this.isObject(v)){
            return Object.keys(v).length === 0;
        }
        if(this.isArray(v)){
            return v.length===0;
        }
        return this.isUndefined(v) || this.isNull(v) || v === null || v === '';
    }

    static isNotNullValue(v:any, trim=false){
        const result =!this.isNullValue(v, trim);
        return result;
    }

    /**
     * 是否为数字类型的值
     * @param v：被验证的值
     * @param trim：如果是字符串，是否去除空格后再验证
     */
    static isNumberValue(v:any, trim=false){
        const result = !isNaN(v);
        return result;
    }

    /**
     * 是否为空数组
     * @param o：被校验的值
     */
    static isEmptyArray(o:any){
        if(this.isArray(o)){
            return o.length===0;
        }else{
            return false;
        }
    }

    /**
     * 是否为非空数组
     * @param o：被校验的值
     */
    static isNotEmptyArray(o:any){
        if(this.isArray(o)){
            return o.length!==0;
        }else{
            return false;
        }
    }

    /**
     * 去除空格
     * @param v：被去除空格的值，要求为string
     */
    static trim(v: string){
        if(v){
            return v.replace(/\s+/g, '');
        }else{
            return '';
        }
    }

    /**
     * 去除左空格
     * @param v：被去除空格的值，要求为string
     */
    static trimL(v: string){
        if(v){
            return v.replace(/(^\s+)|/g, '');
        }else{
            return '';
        }
    }

    /**
     * 去除右空格
     * @param v：被去除空格的值，要求为string
     */
    static trimR(v: string){
        if(v){
            return v.replace(/(\s+$)/g, '');
        }else{
            return '';
        }
    }

    /**
     * 去除左、右空格
     * @param v：被去除空格的值，要求为string
     */
    static trimLR(v: string){
        if(v){
            return v.replace(/(^\s+)|(\s+$)/g, '');
        }else{
            return '';
        }
    }

    public static  isBase64(str){
        if(this.isNullValue(str)){
            return false;
        }
        try{
            return btoa(atob(str)) === str && str.endsWith('=');
        }catch(err){
            return false;
        }
    }

    public static getURLParams(){
        let url = window.location.search;
        let theRequest = {};
        if (url.indexOf("?") != -1) {
            let str = url.substr(1);
            let params = str.split("&");
            for (let i = 0; i < params.length; i++) {
                const keyValues = params[i].split("=");
                if(keyValues.length===2){
                     theRequest[keyValues[0]] = (keyValues[1]);
                }else{
                    const newKeyValues = keyValues.map(v => v===''?'=':v);
                    theRequest[keyValues[0]] = newKeyValues.filter((v,i)=>i!==0).join('');
                }
            }
        }
        return theRequest;
    }
}
